\documentclass[11pt,titlepage, a4paper]{article}
\usepackage[utf8]{inputenc}
\usepackage[francais]{babel}
\usepackage[T1]{fontenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{graphicx}
\usepackage{algpseudocode}
\newcommand{\HRule}{\rule{\linewidth}{0.5mm}}

\begin{document}
\input{titlepage_SCS}
\tableofcontents

\newpage
\input{presentation_Hexxagon_SCS}

\newpage
\section{Communication}

%\subsection*{Programmes à réaliser}
Deux programmes sont nécessaires pour réaliser toutes les communications dans notre projet. Le premier est un serveur qui sera en lien avec l'intelligence artificielle (I.A.) du projet. Le second est un client qui communique avec l'arbitre et le serveur d'I.A.

\subsection{Langages utilisés}
Nous avons décidé de réaliser le client en C afin de faciliter les communications. En effet, l'arbitre et le protocole de communications avec l'arbitre étant codés en C, notre choix nous permet d'éviter tous les problèmes liés à l'endianisme. Il nous permet également de construire les structures du protocole de façon très simple et plu sûre, ce qui permet de minimiser le risque d'erreur.

Pour le serveur d'I.A, nous avons choisi d'utiliser le langage JAVA car il permet de simplifier l'appel aux prédicats Prolog grâce à la librairie Jasper. De plus, nous avons besoin de faire des transformations entre les données renvoyées par le langage Prolog et les envois vers le client, donc le choix nous permet de simplifier toute la partie traitement/transformation des données.


\subsection{Déroulement}
Le jeu se déroule sous forme d'un tournoi contenant plusieurs parties entre deux mêmes joueurs. Au premier tour, le joueur qui est déclaré comme premier joueur par l'arbitre possède la couleur rouge, le second possède la couleur bleue. Les joueurs vont garder ces couleurs pour toutes leurs parties, qu'ils soient premiers ou non pour les suivantes. 

\medskip
Après la connexion au serveur Java d'IA puis à l'arbitre, le tournoi se déroule de la manière suivante :\\
\textbf{Client C :}
\begin{algorithmic}
\State{Connexion avec le serveur d'IA}
\State{Connexion avec l'arbitre}
\State{Envoi d'identification à l'arbitre}
\State{Retour de l'identification de l'arbitre}
\State{Demande de partie à l'arbitre}
\State{Retour demande de partie}
\State{Envoi si premier joueur au serveur d'IA} 
\State{}
\While{!fin tournoi}
	\While{partie continue}
		\If{premier} 
			\State{Reçoit un coup de l'IA}
			\State{Envoie le coup à l'arbitre}
			\State{Reçoit validation de l'arbitre}
			\If{!VALID ou GAGNE ou PERD ou NULLE}
				\State{Fin partie $\leftarrow$ vrai}
				\State{Envoie fin de partie à l'IA}
			\Else
				\State{Reçoit validation coup de l'adversaire}
				\If{!VALID}
					\State{Fin partie $\leftarrow$ vrai}
					\State{Envoie fin de partie à l'IA}
				\Else
					\State{Reçoit coup de l'adversaire}
					\If{GAGNE ou PERD ou NULLE}
						\State{Fin partie $\leftarrow$ vrai}
						\State{Envoie fin de partie à l'IA}
					\Else
						\State{Envoie partie continue à l'IA}
						\State{Envoie coup de l'adversaire à l'IA}
					\EndIf
				\EndIf
			\EndIf
		\Else
			\State{Reçoit validation coup de l'adversaire}
			\If{!VALID}
				\State{Fin partie $\leftarrow$ vrai}
				\State{Envoie fin de partie à l'IA}
			\Else
				\State{Reçoit coup de l'adversaire}
				\If{GAGNE ou PERD ou NULLE}
					\State{Fin partie $\leftarrow$ vrai}
					\State{Envoie fin de partie à l'IA}
				\Else
					\State{Envoie partie continue à l'IA}
					\State{Envoie coup de l'adversaire à l'IA}
					\State{Reçoit un coup de l'IA}
					\State{Envoie le coup à l'arbitre}
					\State{Reçoit validation de l'arbitre}
					\If{!VALID ou GAGNE ou PERD ou NULLE}
						\State{Fin partie $\leftarrow$ vrai}
					\EndIf
					\State{Envoie si partie continue à l'IA}
				\EndIf
			\EndIf
		\EndIf
	\EndWhile
	\State{Demande de partie à l'arbitre}
	\State{Retour demande de partie}
	\State{Envoi si fin de tournoi à l'IA}
\EndWhile
\end{algorithmic}

\medskip
\textbf{Serveur Java :}
\begin{algorithmic}
\State{Création de la socket}
\State{Connexion avec le client C}
\State{Reçoit si premier joueur}
\While{!fin tournoi}
	\While{partie continue}
		\If{Premier joueur}
			\State{Calcul du coup par l'IA}
			\State{Envoie du coup au client}
			\State{Reçoit si partie continue}
			
			\If{Partie continue}
				\State{Reçoit coup de l'adversaire}
				\State{Applique le coup de l'adversaire dans l'IA}
			\EndIf
		\Else
			\State{Reçoit si partie continue}
			\If{Partie continue}
				\State{Reçoit coup de l'adversaire}
				\State{Applique le coup de l'adversaire dans l'IA}
				\State{Calcul du coup par l'IA}
				\State{Envoie du coup au client}
			\EndIf
		\EndIf
	\EndWhile
	\State{Reçoit si fin de tournoi}
\EndWhile
\end{algorithmic}


\subsection{Protocole Client C / Serveur Java d'IA}
Côté Java, la réception d'un coup de l'adversaire consiste en la réception consécutive de 4 entiers, représentant la position du pion en x et en y avant et après le déplacement.\\
 L'envoi d'un coup au client C est effectué par l'envoi consécutif de 6 entiers : le type du coup, un entier pour représenter si le joueur est bloqué, position en x du pion avant déplacement, la position en y du pion avant déplacement, la position en x du pion après le déplacement et la position en y après le déplacement.\\
 L'envoi permettant de signaler si la partie ou le tournoi sont terminés se fait par l'envoi d'un simple entier.

\medskip
Les coordonnées n'ont pas été représentées de la même manière en Prolog et dans l'arbitre. Avant l'envoi d'un nouveau coup du joueur ou après la réception d'un coup de l'adversaire, nous procédons à un calcul pour transcrire les coordonnées.

\medskip
Nous avons rencontré quelques problèmes lors de la communication Java/C, particulièrement dans le sens depuis Java vers C. Les entiers semblaient ne pas être envoyés en totalement, ce qui impliquait des réceptions incorrects dans le joueur C. Nous avons donc créé des petites fonctions pour l'envoi et la réception d'entier entre C et Java.


\subsection{Protocole Arbitre / Client C}
Pour la communication entre le client C et l'arbitre, nous avons respecté le protocole fourni avec l'ordre d'utilisation mentionné précédemment. \\
Ainsi, l'envoi de la demande d'identification à l'arbitre contient la structure du protocole \texttt{TypIndentificationReq} avec le \texttt{TypIdRequest} \texttt{IDENTIFICATION} et le nom du joueur. Le retour de l'indentification contient la structure \texttt{TypIdentificationRep} et informe le client de l'\texttt{identifiant} représentant le joueur. \\
L'envoi de la demande de partie se fait grâce à la structure \texttt{TypPartieReq} avec l'identifiant du joueur obtenu précédemment et le \texttt{TypIdRequest} \texttt{PARTIE}. Le retour de la demande se fait par la réception d'un \texttt{TypPartieRep} contenant plusieurs informations : l'identifiant de l'adversaire, si le tournoi est terminé et si on est le premier joueur dans la partie. \\
L'envoi à l'arbitre du coup à jouer se fait via la structure \texttt{TypCoupReq} qui contient plusieurs information : le type du coup (saut, déplacement, partie gagnée, perdue ou nulle), si le joueur est bloqué après son coup, la position de départ et la position d'arrivée du pion déplacé et le numéro du coup. Le validation de la part de l'arbitre en retour du coup est contenue dans la structure \texttt{TypCoupRep} qui permet de savoir si le coup est valide ou s'il y a triche.\\
Et finalement, avant de recevoir un déplacement venant de l'adversaire, nous recevons une structure \texttt{TypCoupRep} nous signalant si le coup de l'adversaire est valide, suivie d'une structure \texttt{TypCoupReq} représentant le coup de l'adversaire de la même manière que notre coup.



\newpage
\section{Exécution}
Le projet contient un Makefile à sa racine. Il permet de compiler la partie C ainsi que la partie Java avec comme \texttt{classpath} pour Jasper le chemin sur les machines en salles TP.

\medskip
Il y a également un script \texttt{path.sh} qui permet de faire les exports de librairies pour l'exécution de l'arbitre et pour la librairie de sicstus. Il est exécutable par la commande \texttt{. path.sh} à la racine du projet.

\medskip
Un dernier script, \texttt{joueurHexxagon.sh}, permet de lancer le client C et le serveur Java. Ce script a plusieurs paramètre, il se lance de la manière suivant : \texttt{./joueurHexxagon hostArbitre portArbitre}. La connexion entre le client C et l'arbitre s'effectue selon l'adresse et le port passé en paramètre à l'exécution. La connexion entre le client et le serveur d'IA se fait quoi qu'il arrive sur l'adresse \texttt{localhost} et le port 6742.

\end{document}